BOXY – 2D Top-Down Shooter

1. Introduction

BOXY – 2D Top-Down Shooter is a Unity-based action game developed to showcase technical proficiency, design thinking, and a structured production workflow. The project was conceived as a compact yet feature-rich experience demonstrating my capabilities in player control systems, AI design, procedural mechanics, and game polish.

In BOXY, players navigate a minimalistic arena from a top-down perspective, controlling a cube-shaped character that must survive waves of hostile enemies. The gameplay focuses on movement precision, shooting accuracy, and strategic positioning.

This case study documents the full development process — from concept ideation through technical implementation and testing — emphasizing design philosophy, problem-solving, and lessons learned.

2. Concept and Design Goals

The inspiration for BOXY came from the simplicity and readability of classic arcade shooters like Geometry Wars and Asteroids, combined with the modern emphasis on tight controls and visual clarity.

Design Objectives:

• Intuitive Core Mechanics: Deliver responsive movement and shooting controls accessible to any player.
• Challenging AI: Create engaging enemy behaviors that encourage dynamic player movement.
• Minimalist Visuals: Use a clean, geometric art style that reinforces gameplay readability.
• Scalable Architecture: Develop a flexible system architecture to easily extend features such as new weapons, enemies, or levels.
• Polished Gameplay Loop: Ensure fluidity between spawning, combat, scoring, and game-over states.

The overarching design philosophy centered on clarity through simplicity: stripping away unnecessary complexity to highlight tight feedback loops and satisfying combat rhythm.

3. Development Process

3.1 Project Setup

The project began with a clear structural plan, dividing gameplay into core systems — Player, Enemies, Weapons, and Game Management. Each subsystem was implemented as a modular component, allowing for efficient testing and iteration.

A minimalist aesthetic was chosen early: solid-color shapes on a neutral background, ensuring maximum visual clarity during fast-paced play. Early prototypes focused purely on player movement and shooting to establish the “feel” before adding combat elements.

3.2 Player Controls and Movement

The player’s movement system was built around Unity’s Rigidbody2D for physics-driven control. Movement was handled via normalized input vectors, allowing smooth diagonal motion and consistent speed in all directions. Shooting direction was decoupled from movement using independent input axes — one for movement, another for aiming.

Fine-tuning acceleration, deceleration, and maximum velocity became essential to achieving tight, responsive handling. Early playtests emphasized the need for precision over speed, leading to a control model that rewarded deliberate positioning.

3.3 Shooting System and Weapon Design

The weapon system was designed with flexibility in mind. Bullets were implemented as pooled prefabs, managed by an ObjectPooler to optimize performance and minimize garbage collection overhead.

Each projectile carried data for speed, damage, and lifespan. Fire rate and spread could be adjusted to allow experimentation with different weapon archetypes (e.g., single-shot, burst fire). This modularity supported future scalability and rapid iteration during testing.

3.4 Enemy AI and Behavior

Enemy entities operated through state-driven AI scripts. Basic enemy types pursued the player using simple steering behaviors, while more advanced variants incorporated ranged attacks or evasive patterns.

Pathfinding relied on directional steering rather than grid-based navigation, maintaining lightweight computational overhead suitable for real-time performance.

A wave-based spawning system controlled enemy count and pacing, gradually increasing difficulty through frequency and enemy mix. This created a dynamic escalation curve that kept gameplay challenging without overwhelming the player.

3.5 Combat and Feedback

Combat relied heavily on instant feedback to maintain engagement. Particle bursts, hit flashes, and screen shake were integrated to reinforce each interaction.

Damage handling used a centralized HealthManager component for both player and enemy entities, streamlining logic for damage detection and death events. Sound effects and short impact animations were added to emphasize rhythm and reward.

3.6 Game Flow and UI

The game followed a looping structure: Start → Combat → Game Over → Restart.

The GameManager handled transitions between states, spawning waves, tracking score, and detecting defeat conditions. The UI system provided score tracking, health indicators, and restart options using Unity’s Canvas and TextMeshPro.

A minimalist UI layout reinforced the clean visual identity of the game, keeping player focus on movement and survival.

4. Technical Implementation

4.1 Architecture Overview

The code architecture was intentionally modular and event-driven:

• PlayerController: Input handling, movement, and shooting.
• WeaponController: Projectile instantiation, fire rate logic.
• EnemyController: State-driven behavior and movement.
• GameManager: Global state transitions and score tracking.
• UIManager: Updates HUD elements and displays game state.
• ObjectPooler: Manages reusable objects for bullets and effects.

This structure allowed each system to operate independently while communicating through events, promoting scalability and maintainability.

4.2 Performance Optimization

Because numerous objects (enemies, bullets, particles) could exist simultaneously, optimization was crucial. Techniques included:

• Object pooling for all projectiles and particle systems.
• Batching sprites to minimize draw calls.
• Time-based logic using Time.deltaTime to ensure frame-rate consistency.

These optimizations ensured stable performance at 60 FPS even during intense combat scenarios.

4.3 Procedural and Randomized Elements

Enemy spawn locations and wave timing included controlled randomness to enhance replayability. Randomization was balanced with constraints to avoid unfair scenarios — for example, preventing enemies from spawning too close to the player.

5. Challenges and Problem-Solving

5.1 Balancing Speed and Control

Early versions suffered from overly sensitive movement, leading to imprecise aiming and player frustration. The solution involved adjusting acceleration curves and introducing subtle drag to simulate weight, achieving a more grounded feel.

5.2 Collision and Damage Accuracy

High-speed bullets occasionally missed collision detection due to tunneling issues. Switching projectiles to continuous collision detection and implementing hitbox-based validation resolved inconsistencies.

5.3 AI Performance

When enemy numbers increased, performance dips occurred due to redundant physics calculations. Refactoring AI behaviors to avoid unnecessary raycasts and employing coroutine-based logic for timed actions significantly improved stability.

6. Testing and Iteration

Testing followed an iterative cycle: implement → test → refine. Key insights emerged from repeated playtesting:

• Player feedback emphasized the importance of distinct enemy patterns to maintain engagement.
• Balancing weapon fire rate and enemy spawn density was essential to sustain tension without fatigue.
• Small visual cues, such as enemy telegraphs and damage flashes, greatly improved gameplay readability.

Incremental adjustments led to a balanced experience where difficulty scaled naturally, encouraging replayability and mastery.

7. Final Outcome

The finished version of BOXY – 2D Top-Down Shooter delivered on its design objectives:

• Responsive controls that prioritize player precision.
• Dynamic enemy AI that adapts to player movement.
• Clean, minimalist visuals supporting clear gameplay feedback.
• Efficient performance with optimized systems and modular code.
• Engaging combat loop emphasizing skill-based progression.

The game succeeds as both a technical showcase and a creative expression of minimalist design principles within an interactive system.

8. Insights and Lessons Learned

The project offered several key takeaways:

• Player Experience Is Systemic: Every mechanic — from input sensitivity to enemy AI — contributes to overall “game feel.”
• Modular Architecture Enables Flexibility: Separating logic by responsibility allowed rapid iteration without major refactoring.
• Balancing Is Continuous: Small parameter adjustments dramatically affect pacing, difficulty, and satisfaction.
• Optimization Must Be Intentional: Early adoption of pooling and efficient logic prevents late-stage performance issues.
• Feedback Matters: Subtle audio-visual cues are crucial for making moment-to-moment actions feel rewarding.

These insights reinforced the importance of iterative design and holistic thinking in game development — balancing technical execution with experiential design.

9. Future Improvements

Potential future extensions include:

• Expanded Weapon System: Introducing multiple weapon types and upgrade paths.
• Enemy Variety: Adding bosses, ranged enemies, and pattern-based challenges.
• Procedural Levels: Incorporating randomized arena layouts for replayability.
• Audio Layering: Implementing adaptive background music that responds to gameplay intensity.
• Persistence: Adding player progression or unlockable content to extend engagement.

Each of these enhancements would build upon the existing foundation while deepening the game’s tactical and sensory depth.

10. Conclusion

BOXY – 2D Top-Down Shooter represents a comprehensive exercise in both creative and technical game development. Through its creation, I refined my skills in Unity programming, systems design, and iterative problem-solving. The project demonstrates not only proficiency in building functional game systems but also an understanding of how subtle design choices influence the player experience.

By combining clean architecture, responsive mechanics, and deliberate aesthetic restraint, BOXY achieves a balance between simplicity and depth — an embodiment of effective design through focus.